package com.creed.energy.project.system.common.utils;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.TreeNode;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.json.JsonMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import lombok.extern.slf4j.Slf4j;
import org.springframework.lang.Nullable;

import java.io.*;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.Objects;

/**
 * @author btmood
 * @version 1.0
 * @apiNote jackson工具类
 * @since 2023-11-19 22:06
 */
@Slf4j
public class JsonUtils {
    private final JsonMapper MAPPER_LOWER_CAMEL_CASE;
    private final JsonMapper MAPPER_SNAKE_CASE;

    private static class Bean {
        static final JsonUtils INSTANCE = new JsonUtils();
    }

    public static JsonUtils getInstance() {
        return Bean.INSTANCE;
    }

    private JsonUtils() {
        MAPPER_LOWER_CAMEL_CASE = JsonMapper.builder()
                .configure(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY, true)
                .configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true)
                .configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false)
                .serializationInclusion(JsonInclude.Include.NON_NULL)
                .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
                .defaultDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"))
                .addModule(new JavaTimeModule())
                .build();
        MAPPER_SNAKE_CASE = JsonMapper.builder()
                .configure(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY, true)
                .configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true)
                .configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false)
                .serializationInclusion(JsonInclude.Include.NON_NULL)
                .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
                .propertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE)
                .defaultDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"))
                .addModule(new JavaTimeModule())
                .build();
    }

    /**
     * 序列化对象为JSON字符串的方法（会过滤掉null值）
     *
     * @param value         待序列化的对象
     * @param prettyPrinter 输出美化后的JSON字符串
     * @return 返回JSON字符串（如果对象转换错误将返回""字符串）
     */
    @Nullable
    public String serialize(Object value, boolean... prettyPrinter) {
        try {
            if (prettyPrinter != null && prettyPrinter.length > 0 && prettyPrinter[0]) {
                return MAPPER_LOWER_CAMEL_CASE.writerWithDefaultPrettyPrinter().writeValueAsString(value);
            }
            return MAPPER_LOWER_CAMEL_CASE.writeValueAsString(value);
        } catch (JsonProcessingException e) {
            log.error("序列化失败。(content={}, stack={})", value, e.getMessage());
            return null;
        }
    }

    /**
     * 序列化对象为JSON字符串的方法
     *
     * @param value         待序列化的对象
     * @param prettyPrinter 输出美化后的JSON字符串
     * @return 返回JSON字符串（如果对象转换错误将返回""字符串）
     */
    @Nullable
    public String serializeBySnake(Object value, boolean... prettyPrinter) {
        try {
            if (prettyPrinter != null && prettyPrinter.length > 0 && prettyPrinter[0]) {
                return MAPPER_SNAKE_CASE.writerWithDefaultPrettyPrinter().writeValueAsString(value);
            }
            return MAPPER_SNAKE_CASE.writeValueAsString(value);
        } catch (JsonProcessingException e) {
            log.error("序列化失败。(content={}, stack={})", value, e.getMessage());
            return null;
        }
    }

    /**
     * 将指定对象序列化为字节数组的方法
     *
     * @param value 需要序列化的对象
     * @return 返回字节数组
     */
    @Nullable
    public byte[] serializeBytes(Object value) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.writeValueAsBytes(value);
        } catch (JsonProcessingException e) {
            log.error("序列化失败。(content={}, stack={})", value, e.getMessage());
            return null;
        }
    }

    /**
     * 将指定对象序列化为字节数组的方法
     *
     * @param value 需要序列化的对象
     * @return 返回字节数组
     */
    @Nullable
    public byte[] serializeBytesBySnake(Object value) {
        try {
            return MAPPER_SNAKE_CASE.writeValueAsBytes(value);
        } catch (JsonProcessingException e) {
            log.error("序列化失败。(content={}, stack={})", value, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化JSON字符串的方法
     *
     * @param content   JSON字符串
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserialize(String content, Class<T> valueType) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.readValue(content, valueType);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(content={},class={}, stack={})", content, valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化JSON字符串的方法
     *
     * @param content   JSON字符串
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializeBySnake(String content, Class<T> valueType) {
        try {
            return MAPPER_SNAKE_CASE.readValue(content, valueType);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(content={},class={}, stack={})", content, valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化JSON字符串的方法
     *
     * @param content      JSON字符串
     * @param valueTypeRef 反序列化字符串的类型
     * @param <T>          JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserialize(String content, TypeReference<T> valueTypeRef) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.readValue(content, valueTypeRef);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(content={},class={}, stack={})", content, valueTypeRef, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化JSON字符串的方法
     *
     * @param content      JSON字符串
     * @param valueTypeRef 反序列化字符串的类型
     * @param <T>          JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializeBySnake(String content, TypeReference<T> valueTypeRef) {
        try {
            return MAPPER_SNAKE_CASE.readValue(content, valueTypeRef);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(content={},class={}, stack={})", content, valueTypeRef, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化输入流内容为指定类型对象的方法
     *
     * @param src   输入流对象
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserialize(InputStream src, Class<T> valueType) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.readValue(src, valueType);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(class={}, stack={})", valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化输入流内容为指定类型对象的方法
     *
     * @param src   输入流对象
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializeBySnake(InputStream src, Class<T> valueType) {
        try {
            return MAPPER_SNAKE_CASE.readValue(src, valueType);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(class={}, stack={})", valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化输入流内容为指定类型对象的方法
     *
     * @param src      输入流对象
     * @param valueTypeRef 反序列化字符串的类型
     * @param <T>          JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserialize(InputStream src, TypeReference<T> valueTypeRef) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.readValue(src, valueTypeRef);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(class={}, stack={})", valueTypeRef, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化输入流内容为指定类型对象的方法
     *
     * @param src      输入流对象
     * @param valueTypeRef 反序列化字符串的类型
     * @param <T>          JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializeBySnake(InputStream src, TypeReference<T> valueTypeRef) {
        try {
            return MAPPER_SNAKE_CASE.readValue(src, valueTypeRef);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(class={}, stack={})", valueTypeRef, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化URL内容为指定类型对象的方法
     *
     * @param url   URL对象
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserialize(URL url, Class<T> valueType) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.readValue(url, valueType);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(url={}, class={}, stack={})", url, valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化URL内容为指定类型对象的方法
     *
     * @param url   URL对象
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializeBySnake(URL url, Class<T> valueType) {
        try {
            return MAPPER_SNAKE_CASE.readValue(url, valueType);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(url= {}, class={}, stack={})", url, valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化URL内容为指定类型对象的方法
     *
     * @param url   URL对象
     * @param valueTypeRef 反序列化字符串的类型
     * @param <T>          JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserialize(URL url, TypeReference<T> valueTypeRef) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.readValue(url, valueTypeRef);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(url={}, class={}, stack={})", url, valueTypeRef, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化URL内容为指定类型对象的方法
     *
     * @param url   URL对象
     * @param valueTypeRef 反序列化字符串的类型
     * @param <T>          JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializeBySnake(URL url, TypeReference<T> valueTypeRef) {
        try {
            return MAPPER_SNAKE_CASE.readValue(url, valueTypeRef);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(url={}, class={}, stack={})",
                    url, valueTypeRef, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化文件内容为目标类型对象的方法
     *
     * @param file   文件对象
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserialize(File file, Class<T> valueType) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.readValue(file, valueType);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(file={}, class={}, stack={})",
                    file.getAbsoluteFile(), valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化文件内容为目标类型对象的方法
     *
     * @param file   文件对象
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializeBySnake(File file, Class<T> valueType) {
        try {
            return MAPPER_SNAKE_CASE.readValue(file, valueType);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(file={}, class={}, stack={})",
                    file.getAbsoluteFile(), valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化文件内容为目标类型对象的方法
     *
     * @param file      文件对象
     * @param valueTypeRef 反序列化字符串的类型
     * @param <T>          JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserialize(File file, TypeReference<T> valueTypeRef) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.readValue(file, valueTypeRef);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(file={}, class={}, stack={})",
                    file, valueTypeRef, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化文件内容为目标类型对象的方法
     *
     * @param file      文件对象
     * @param valueTypeRef 反序列化字符串的类型
     * @param <T>          JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializeBySnake(File file, TypeReference<T> valueTypeRef) {
        try {
            return MAPPER_SNAKE_CASE.readValue(file, valueTypeRef);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(class={}, stack={})", valueTypeRef, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化字符流内容为目标类型对象的方法
     *
     * @param reader   字符流对象
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserialize(Reader reader, Class<T> valueType) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.readValue(reader, valueType);
        } catch (IOException e) {
            log.error("当前字符流与需要转换的类型不匹配，转换失败。(class={}, stack={})", valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化字符流内容为目标类型对象的方法
     *
     * @param reader   字符流对象
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializeBySnake(Reader reader, Class<T> valueType) {
        try {
            return MAPPER_SNAKE_CASE.readValue(reader, valueType);
        } catch (IOException e) {
            log.error("当前字符流与需要转换的类型不匹配，转换失败。(class={}, stack={})", valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化字符流内容为目标类型对象的方法
     *
     * @param reader   字符流对象
     * @param valueTypeRef 反序列化字符串的类型
     * @param <T>          JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserialize(Reader reader, TypeReference<T> valueTypeRef) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.readValue(reader, valueTypeRef);
        } catch (IOException e) {
            log.error("当前字符流与需要转换的类型不匹配，转换失败。(class={}, stack={})", valueTypeRef, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化字符流内容为目标类型对象的方法
     *
     * @param reader   字符流对象
     * @param valueTypeRef 反序列化字符串的类型
     * @param <T>          JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializeBySnake(Reader reader, TypeReference<T> valueTypeRef) {
        try {
            return MAPPER_SNAKE_CASE.readValue(reader, valueTypeRef);
        } catch (IOException e) {
            log.error("当前字符流与需要转换的类型不匹配，转换失败。(class={}, stack={})", valueTypeRef, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化字符流内容为目标类型对象的方法
     *
     * @param input   数据输入流对象
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserialize(DataInput input, Class<T> valueType) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.readValue(input, valueType);
        } catch (IOException e) {
            log.error("当前字符流与需要转换的类型不匹配，转换失败。(class={}, stack={})", valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化字符流内容为目标类型对象的方法
     *
     * @param input   数据输入流对象
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializeBySnake(DataInput input, Class<T> valueType) {
        try {
            return MAPPER_SNAKE_CASE.readValue(input, valueType);
        } catch (IOException e) {
            log.error("当前字符流与需要转换的类型不匹配，转换失败。(class={}, stack={})", valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化JSON Payload的方法
     *
     * @param parser   JSON解析器对象
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserialize(JsonParser parser, Class<T> valueType) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.readValue(parser, valueType);
        } catch (IOException e) {
            log.error("当前解析器解析的内容与需要转换的类型不匹配，转换失败。(class={}, stack={})", valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化JSON Payload的方法
     *
     * @param parser   JSON解析器对象
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializeBySnake(JsonParser parser, Class<T> valueType) {
        try {
            return MAPPER_SNAKE_CASE.readValue(parser, valueType);
        } catch (IOException e) {
            log.error("当前解析器解析的内容与需要转换的类型不匹配，转换失败。(class={}, stack={})",
                    valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化JSON Payload的方法
     *
     * @param parser   JSON解析器对象
     * @param valueTypeRef 反序列化字符串的类型
     * @param <T>          JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserialize(JsonParser parser, TypeReference<T> valueTypeRef) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.readValue(parser, valueTypeRef);
        } catch (IOException e) {
            log.error("当前解析器解析的内容与需要转换的类型不匹配，转换失败。(stack={})",
                    e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化JSON Payload的方法
     *
     * @param parser   JSON解析器对象
     * @param valueTypeRef 反序列化字符串的类型
     * @param <T>          JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializeBySnake(JsonParser parser, TypeReference<T> valueTypeRef) {
        try {
            return MAPPER_SNAKE_CASE.readValue(parser, valueTypeRef);
        } catch (IOException e) {
            log.error("当前解析器解析的内容与需要转换的类型不匹配，转换失败。(stack={})",
                    e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化树结构对象为指定类型对象的方法
     *
     * @param node   树节点对象
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserialize(TreeNode node, Class<T> valueType) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.treeToValue(node, valueType);
        } catch (IOException e) {
            log.error("当前解析器解析的内容与需要转换的类型不匹配，转换失败。(class={}, stack={})", valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化JSON Payload的方法
     *
     * @param payload   数据负载
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializePayload(byte[] payload, Class<T> valueType) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.readValue(payload, valueType);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(content={}, class={}, stack={})",
                    new String(payload), valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化JSON Payload的方法
     *
     * @param payload   数据负载
     * @param valueType 反序列化字符串的类型
     * @param <T>       JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializePayloadBySnake(byte[] payload, Class<T> valueType) {
        try {
            return MAPPER_SNAKE_CASE.readValue(payload, valueType);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(content={}, class={}, stack={})",
                    new String(payload), valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化JSON Payload的方法
     *
     * @param payload      数据负载
     * @param valueTypeRef 反序列化字符串的类型
     * @param <T>          JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializePayload(byte[] payload, TypeReference<T> valueTypeRef) {
        try {
            return MAPPER_LOWER_CAMEL_CASE.readValue(payload, valueTypeRef);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(content={}, stack={})",
                    new String(payload), e.getMessage());
            return null;
        }
    }

    /**
     * 反序列化JSON Payload的方法
     *
     * @param payload      数据负载
     * @param valueTypeRef 反序列化字符串的类型
     * @param <T>          JSON字符串对应的实体类型
     * @return 返回反序列化后的结果
     */
    @Nullable
    public <T> T deserializePayloadBySnake(byte[] payload, TypeReference<T> valueTypeRef) {
        try {
            return MAPPER_SNAKE_CASE.readValue(payload, valueTypeRef);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(content={}, stack={})",
                    new String(payload), e.getMessage());
            return null;
        }
    }

    @Nullable
    public <T> T convertMapToBean(Object obj, TypeReference<T> valueTypeRef) {
        try {
            String serialize = serialize(obj);
            return MAPPER_LOWER_CAMEL_CASE.readValue(serialize, valueTypeRef);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(content={},class={}, stack={})", obj, valueTypeRef, e.getMessage());
            return null;
        }
    }

    @Nullable
    public <T> T convertMapToBeanBySnake(Object obj, TypeReference<T> valueTypeRef) {
        try {
            String serialize = serialize(obj);
            return MAPPER_SNAKE_CASE.readValue(serialize, valueTypeRef);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(content={},class={}, stack={})", obj, valueTypeRef, e.getMessage());
            return null;
        }
    }

    @Nullable
    public <T> T convertMapToBean(Object obj, Class<T> valueType) {
        try {
            String serialize = serialize(obj);
            return MAPPER_LOWER_CAMEL_CASE.readValue(serialize, valueType);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(content={},class={}, stack={})", obj, valueType, e.getMessage());
            return null;
        }
    }

    @Nullable
    public <T> T convertMapToBeanBySnake(Object obj, Class<T> valueType) {
        try {
            String serialize = serialize(obj);
            return MAPPER_SNAKE_CASE.readValue(serialize, valueType);
        } catch (IOException e) {
            log.error("当前内容与需要转换的类型不匹配，转换失败。(content={},class={}, stack={})", obj, valueType, e.getMessage());
            return null;
        }
    }

    /**
     * 将Json字符串转换为通用JSON格式对象的方法
     *
     * @param jsonString 待转换的对象
     * @return 返回 JSON 通用格式对象
     */
    @Nullable
    public JsonNode convertJsonNode(String jsonString) {
        if (Objects.isNull(jsonString)) {
            log.warn("待解析的对象不能为null。");
            return null;
        }
        try {
            return MAPPER_LOWER_CAMEL_CASE.readTree(jsonString);
        } catch (JsonProcessingException e) {
            log.error("当前内容无法转换为JsonNode对象，转换失败。", e);
            return null;
        }
    }

    /**
     * 将Json字符串转换为通用JSON格式对象的方法
     *
     * @param jsonString 待转换的Json字符串
     * @return 返回 JSON 通用格式对象
     */
    @Nullable
    public JsonNode convertJsonNodeBySnake(String jsonString) {
        if (Objects.isNull(jsonString)) {
            log.warn("待解析的对象不能为null。");
            return null;
        }
        try {
            return MAPPER_SNAKE_CASE.readTree(jsonString);
        } catch (JsonProcessingException e) {
            log.error("当前内容无法转换为JsonNode对象，转换失败。", e);
            return null;
        }
    }

    /**
     * 将对象转换为通用JSON格式对象的方法（Json字符串请勿使用该方法）
     *
     * @param obj 待转换的对象
     * @return 返回 JSON 通用格式对象
     * @see #convertJsonNode(String) Json字符串格式化请使用 {@code convertJsonNode(String)} 方法
     */
    @Nullable
    public JsonNode toJsonNode(Object obj) {
        if (Objects.isNull(obj)) {
            log.warn("待解析的对象不能为null。");
            return null;
        }
        String serialize = serialize(obj);
        try {
            return MAPPER_LOWER_CAMEL_CASE.readTree(serialize);
        } catch (JsonProcessingException e) {
            log.error("当前内容无法转换为JsonNode对象，转换失败。", e);
            return null;
        }
    }

    /**
     * 将对象转换为通用JSON格式对象的方法（Json字符串请勿使用该方法）
     *
     * @param obj 待转换的对象
     * @return 返回 JSON 通用格式对象
     * @see #convertJsonNodeBySnake(String) Json字符串格式化请使用 {@code convertJsonNodeBySnake(String)} 方法
     */
    @Nullable
    public JsonNode toJsonNodeBySnake(Object obj) {
        if (Objects.isNull(obj)) {
            log.warn("待解析的对象不能为null。");
            return null;
        }
        String serialize = serialize(obj);
        try {
            return MAPPER_SNAKE_CASE.readTree(serialize);
        } catch (JsonProcessingException e) {
            log.error("当前内容无法转换为JsonNode对象，转换失败。", e);
            return null;
        }
    }
}
